mr-parser

mr-parser

Parses mathematical expressions and outputs an AST

• Description
  • why?
  • Grammar
• Install
• Usage
• API
  • Parser = require('mr-parser').Parser
    • Parser.parse(expression)

Description

mr-parser is a lightweight mathematical parser inspired by math.js expression parser, unlike math.js expression parser the AST nodes contain no info on how to compile a node which makes the parser modular

why?

I felt that I had to make another parser because:

• math-parser is too simple for me, it just operates on numbers and has the following operators +, -, *, / and ^ and doesn't have variable substitution
• math.js expression parser is perfect but it's not modularized yet, to use it one would have to include all the source code of math.js
• math.js expression parser AST nodes have info about how to compile a node, I think it's better to let another module do that

Grammar

program          : block (; block)*

block            : assignment

assignment       : ternary
                 | symbol `=` assignment

ternary          : logicalOR
                 | logicalOR `?` ternary `:` ternary

logicalOR        : logicalXOR
                 | logicalXOR (`||`,`or`) logicalOR

logicalXOR       : logicalAND
                 : logicalAND `xor` logicalXOR

logicalAND       : bitwiseOR
                 | bitwiseOR (`&&`,`and`) logicalAND

bitwiseOR        : bitwiseXOR
                 | bitwiseXOR `|` bitwiseOR

bitwiseXOR       : bitwiseAND
                 | bitwiseAND `^|` bitwiseXOR

bitwiseAND       : relational
                 | relational `&` bitwiseAND

relational       : shift
                 | shift (`!=` | `==` | `>` | '<' | '<=' |'>=') shift)

shift            : additive
                 | additive (`>>` | `<<` | `>>>`) shift

additive         : multiplicative
                 | multiplicative (`+` | `-`) additive

multiplicative   : unary
                 | unary (`*` | `/` | `%`) multiplicative
                 | unary symbol

unary            : pow
                 | (`-` | `+` | `~`) unary

pow              : factorial
                 | factorial (`^`, '**') unary

factorial        : symbol
                 | symbol (`!`)

symbol           : symbolToken
                 | symbolToken functionCall
                 | string

functionCall     : `(` `)`
                 | `(` ternary (, ternary)* `)`

string           : `'` (character)* `'`
                 : `"` (character)* `"`
                 | array

array            : `[` `]`
                 | `[` assignment (, assignment)* `]`
                 | number

number           : number-token
                 | parentheses

parentheses      : `(` assignment `)`
                 : end

end              : null-token

Install

$ npm install --save mr-parser

Usage

var Parser = require('mr-parser').Parser;
Parser.parse('1 * (2 + 3) * 4')

// returns
{
  blocks:[{
    op: '*',
    args: [{
      value: '1',
      valueType: 'number'
    }, {
      op: '*',
      args: [{
        op: '+',
        args: [
          { value: '2', valueType: 'number' },
          { value: '3', valueType: 'number' }
        ]
      }, {
        value: '4',
        valueType: 'number'
      }]
    }]
  }]
} 

Parser.parse('2x')

// returns
{
  blocks: [{
    op: '*',
    args: [
      { value: '2', valueType: 'number' },
      { name: 'x' }
    ]
  }]
}

API

Parser = require('mr-parser').Parser

Parser.parse(expression)

params

• expression {string} the expression to be parsed

returns

• Returns an array of possibly nested nodes which is the AST that represents the expression

2015 MIT © Mauricio Poppe